一、TS是什么

	TypeScript是JavaScript类型的超集，它可以编译成纯JavaScript。

二、TS最主要的用途
	
	1. 约束类型
	2. TS最后要编译JS

三、搭建环境
	
	https://www.xuexiluxian.cn/blog/detail/8b8e67922a714696820cd7cefc0526ab
	
四、数据类型
	
	4.1 字符串类型
		let str: string = '你好呀';
	4.2 数值类型
		let num: number = 123;
	4.3 布尔类型
		let bool: boolean = true;
	4.4 any
		let n:any = [1,2,3];
		可以接受所有的数据类型

	4.5 undefined
		let un:undefined = undefined;
	4.6 null
		let nu: null = null;
	4.7 数组

		a> 数组的每一个成员都是number类型

			let arr1: number[] = [1,2,3,4];

		b> 数组的成员可能有某些类型

			let arr2: (string|number)[] = ['a','b','c',1];

		c> 数组的每一个成员都是number类型

			let arr3: Array<number>= [1,2,3,4];

		d> 元组的形式 ： 规定每一位成员的类型

			let arr4:[string,string,number] = ['a','b',10];

	4.8 void：代表没有返回值

		function fun(a:number ,b:number ):void{
		    let c = a+b;
		}
		fun(1,2);

	4.9 object

		let obj:object = { 
		    message:'成功',
		    data:{
		        list:['a','b','c']
		    },
		    success:true
		 }; 


五、函数的约束
	
	5.1 普通写法

		function fun1( a:number ,b:number ): number {
		    return a + b;
		}
		fun1( 1, 2 );

	5.2 函数的可选参数 : 缺省?

		function fun2( a:number ,b?:number ): void{
		    
		}
		fun2( 1 )

	5.3 函数参数的默认值

		function fun3( a:number , b:number=111 ){

		}

		fun3(  1 , 2  );


	5.3 变量或者常量来声明函数的写法

		
		let fun4:(a:number,b:number)=>number = ( a:number , b:number ):number =>{

		    return a + b;

		}
		fun4( 1 , 2 );


六、interface ： 接口
	
	6.1 基本写法

		定义：
			interface Iobj{
			    a:number;
			    b:number;
			}

			*** 1. 首字母I开头并且是大写
			*** 2. 每一行的结束要用;分割

		使用：
			let obj:Iobj = {
			    a:1,
			    b:2
			}

	6.2 缺省

		interface Idata{
		    message:string;
		    success:boolean;
		    data?:{}
		}

		let obj1:Idata = {
		    message:'成功',
		    success:true
		}

		let obj2:Idata = {
		    message:'成功',
		    success:true,
		    data:{}
		}

	6.3 只读属性

		interface Iobj{
		    readonly a:number;
		    b:number;
		}

		**只能获取a，不能修改a

	6.4 interface 使用 interface 

		interface Ilist{
		    list:{id:number;name:string;}[];
		}
		interface Idata{
		    message:string;
		    success:boolean;
		    data:Ilist;
		}

		let data:Idata = {
		    message:'成功',
		    success:true,
		    data:{
		        list:[
		            {id:1,name:'你好11'},
		            {id:2,name:'你好22'}
		        ]
		    }
		}


七、类和抽象类
		
	ES13：https://www.xuexiluxian.cn/course/detail/2c40e53d494e4aedb334b9335ee21463

	7.1 写法

		class Person{
		    userName:string
		    userAge:number
		    constructor(name:string,age:number){
		        this.userName = name;
		        this.userAge = age;
		    }
		    run():number{
		        return this.userAge;
		    }
		    
		}

		let p1 = new Person('张三',28); 

	7.2 修饰符

		public  	公开的，在任何地方都可以访问
		protected 	受保护的，只能在当前类和当前类的子类内部使用
		private 	私有的，当前类的内部使用

	7.3 抽象类

		写法

			abstract class Person{
			    abstract run():number;
			}

			***1. 抽象类不可以new
			***2. 如果有类继承抽象类，必须在类中要实现抽象类中的方法


八、implements和interface继承

	8.1 implements使用 : 通过interface来约束类

		interface Ipo1{
		    userName:string;
		    run():number;
		}

		interface Ipo2{
		    userAge:number;
		}

		class Person implements Ipo1,Ipo2{ //****
		    userName: string
		    userAge:number
		    run(){
		        return 1;
		    }
		}

	8.2 interface继承

		interface Ipo1{
		    userName:string;
		    run():number;
		}

		interface Ipo2 extends Ipo1{  //****
		    userAge:number;
		}

		class Person implements Ipo2{
		    userName: string
		    userAge:number
		    run(){
		        return 1;
		    }
		}


九、泛型

	9.1 什么是泛型

		泛型：是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。


	9.2 函数的泛型

		function fun1<T>( arg:T): T {
		    return arg;
		}

		fun1<string>('你好');
		fun1<number>(123);


		***这里的T，是一个标识符，可以写成任何的东西，一般写成：T、U、M

		也可以定义多个泛型:
			function fun2<T,U>( a:T,b:U){
			        
			}
			fun2<number,string>(1,'2');

	9.3 来看一个需求，说这个泛型，需要有length属性


		function fun3<T extends String | string[]>( arg:T ): number {
		    
		    return arg.length;

		}

		fun3<string>('你好');
		fun3<string[]>(['a','b']);


		*** 以上 ｜ 叫联合声明

	9.4 泛型接口

		写法一：
		interface IArg{
		    length:number;
		}
		function fun4<T extends IArg>( arg:T): number {
		    return arg.length;
		}
		fun4<string>('你好');
		fun4<string[]>(['a','b']);
		fun4<number[]>([1,2,3]);	



		写法二：
		interface Idata<T>{
		    a:T;
		    b:T;
		    c:string;
		}

		let data:Idata<number> = {
		    a:1,
		    b:2,
		    c:'aaaa'
		}

	9.5 class类泛型

		class Person<T,U>{
		    userName:T;
		    userage:U;
		    constructor( name:T, age:U ){
		        this.userName = name;
		        this.userage = age;
		    }
		}

		let p1 = new Person<string,number>('你好',28);













	